home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 031-040 / amok39 / rdt / rdt.mod < prev    next >
Text File  |  1993-11-04  |  24KB  |  701 lines

  1. (*-------------------------------------------------------------------------
  2.  
  3.   :Program.       RDT.mod   (* Replace Default Tool *)
  4.   :Author.        Reinhard Geisler
  5.   :Address.       Plockhorstweg 20, D-4178 Kevelaer 3
  6.   :Phone.         02832-80320
  7.   :Version.       0.3
  8.   :Date.          4 Mar 90
  9.   :Copyright.     Public Domain - only non-commercial
  10.   :Language.      MODULA-II
  11.   :Translator.    M2Amiga V3.3d
  12.   :History.       V0.1  First release - for beta testers only      20 Oct 89
  13.   :History.       V0.2  Updated for M2Amiga V3.3d - not released   22 Dec 89
  14.   :History.       V0.3  partly rewritten and new options added
  15.   :History.             now my own checking on Ctrl-C
  16.   :History.             also works with Workbench now
  17.   :History.             first official release                      4 Mar 90
  18.   :Contents.      Replaces the Default-Tool in the Icon/.info file
  19.   :Remark.        Thanks to Helmut Dalege for the idea
  20.   :Remark.        Also credits for Jochen Kupfer and Peter Fischer for
  21.   :Remark.             beta testing and suggestions
  22.   :Usage.         RDT [DIR/File] [<OldToolname>  <NewToolname>] [-l -s -i]
  23.   :Usage.           -l  :  lists all filenames with toolnames
  24.   :Usage.           -s  :  shows all avaiable toolnames
  25.   :Usage.           -i  :  interactive - ? on input line for more help
  26.  
  27. -------------------------------------------------------------------------*)
  28.  
  29. MODULE RDT;   (* Replace Default Tool *)
  30.    (* Programmaufruf: RDT  Directory  OldToolname  NewToolname  Optionen
  31.       Directory ist der Name des Directory, in dem die Default-Toolnamen
  32.       ersetzt werden sollen. Directory kann auch ein Devicename sein.
  33.       Es werden alle weiteren Sub-directories mit abgearbeitet.
  34.  
  35.       OldToolname ist der alte Default-Toolname.
  36.       NewToolname ist der neue Default-Toolname.
  37.  
  38.       z.B.  RDT  DF0:  M2:m2emacs  M2:DME
  39.             RDT  DF0:Tools  Utilities:More  c:MuchMore
  40.  
  41.       Als Optionen stehen -l, -s und -i zur Verfuegung
  42.           -l  :  list    Es werden alle Filenamen und die Toolnamen
  43.                          aufgefuehrt
  44.           -s  :  show    Es wird jeder vorkommende Toolname einmal
  45.                          aufgefuehrt
  46.           -i  :  interactive
  47.                          Eingabeaufforderung bei jedem File an den User
  48.                          ? bei der Eingabe fuer weitere Hilfe
  49.       Hinweis: Bei der Eingabe von * oder #? fuer den OldToolname werden
  50.                alle Project-Icon-Files auf den NewToolname gesetzt!
  51.  
  52.                "" als leerer Filename ist jetzt erlaubt!
  53.     *)
  54.  
  55.  
  56. FROM  SYSTEM  IMPORT
  57.         ADR, ADDRESS, LONGSET;
  58. FROM  Arts  IMPORT
  59.         wbStarted, Assert, CurrentLevel, DetectCtrlC, Terminate,
  60.         TermProcedure;
  61. FROM  Arguments  IMPORT
  62.         GetArg, NumArgs;
  63. FROM  Dos  IMPORT
  64.         ctrlC, sharedLock, FileLockPtr, Lock, UnLock,
  65.         FileInfoBlockPtr, Examine, ExNext;
  66. FROM  Exec  IMPORT
  67.         SetSignal;
  68. FROM  Heap  IMPORT
  69.         Allocate, Deallocate;
  70. FROM  Str  IMPORT
  71.         CapString, Compare, Concat, Copy, Length;
  72. FROM  Strings  IMPORT
  73.         last, Occurs;
  74. FROM  Terminal  IMPORT
  75.         ReadLn, Write, WriteString, WriteLn;
  76. FROM  ASCII  IMPORT
  77.         csi;
  78. FROM  Icon  IMPORT
  79.         GetDiskObject, PutDiskObject, FreeDiskObject;
  80. FROM  Workbench  IMPORT
  81.         WBObjectType, DiskObjectPtr;
  82.  
  83.  
  84. CONST
  85.   copyright  =  "  Replace-Default-Tool V0.3   (C) by Reinhard Geisler";
  86.   usage      =  "  RDT [DIR/File] [<OldToolname>  <NewToolname>] [-l -s -i]";
  87.  
  88.  
  89. TYPE
  90.   String          =  ARRAY [0..127] OF CHAR;
  91.   LockListPtr     =  POINTER TO LockList;
  92.   LockList        =  RECORD
  93.                        lock  :  FileLockPtr;
  94.                        fib   :  FileInfoBlockPtr;
  95.                        name  :  String;
  96.                        next  :  LockListPtr;
  97.                      END;
  98.   ReplaceListPtr  =  POINTER TO ReplaceList;
  99.   ReplaceList     =  RECORD
  100.                        name  :  String;
  101.                        next  :  ReplaceListPtr;
  102.                      END;
  103.   ShowListPtr     =  POINTER TO ShowList;
  104.   ShowList        =  RECORD
  105.                        name  :  String;
  106.                        next  :  ShowListPtr;
  107.                      END;
  108.   Work            =  (replace, list, show, interactive);
  109.   WorkSet         =  SET OF Work;
  110.  
  111.  
  112. VAR
  113.   error                     :  BOOLEAN;
  114.   errormessage, dirname,
  115.   oldToolname, newToolname  :  String;
  116.   lockListHeadPtr           :  LockListPtr;
  117.   replaceListHeadPtr        :  ReplaceListPtr;
  118.   showListHeadPtr           :  ShowListPtr;
  119.   eraseLine                 :  ARRAY [0..3] OF CHAR;
  120.   icon                      :  DiskObjectPtr;   (* global for Cleanup *)
  121.   status                    :  BOOLEAN;   (* global for -r option *)
  122.   myWorkSet                 :  WorkSet;
  123.  
  124.  
  125.  
  126. PROCEDURE CheckCtrlC;
  127.     BEGIN
  128.       IF (SetSignal(LONGSET{}, LONGSET{}) * LONGSET{ctrlC}) # LONGSET{} THEN
  129.          (* Ctrl-C pressed - abort *)
  130.         WriteLn; WriteLn;
  131.         WriteString("*** BREAK");
  132.         WriteLn;
  133.         Terminate(CurrentLevel());
  134.       END;
  135.   END CheckCtrlC;
  136.  
  137.  
  138.  
  139. PROCEDURE DeallocLockList;
  140.   VAR
  141.     deallocPtr  :  LockListPtr;
  142.  
  143.   BEGIN
  144.     WHILE lockListHeadPtr # NIL DO
  145.       WITH lockListHeadPtr^ DO
  146.         IF fib # NIL THEN
  147.           Deallocate(fib);
  148.         END;
  149.         IF lock # NIL THEN
  150.           UnLock(lock);
  151.         END;
  152.       END;   (* WITH *)
  153.       deallocPtr := lockListHeadPtr;
  154.       lockListHeadPtr := lockListHeadPtr^.next;
  155.       Deallocate(deallocPtr);
  156.     END; (* WHILE *)
  157.   END DeallocLockList;
  158.  
  159.  
  160.  
  161. PROCEDURE Cleanup();
  162.   VAR
  163.     deallocPtr  :  ADDRESS;
  164.  
  165.   BEGIN
  166.     IF icon # NIL THEN
  167.       FreeDiskObject(icon);
  168.     END;
  169.     DeallocLockList;
  170.     WHILE replaceListHeadPtr # NIL DO
  171.       deallocPtr := replaceListHeadPtr;
  172.       replaceListHeadPtr := replaceListHeadPtr^.next;
  173.       Deallocate(deallocPtr);
  174.     END;
  175.     WHILE showListHeadPtr # NIL DO
  176.       deallocPtr := showListHeadPtr;
  177.       showListHeadPtr := showListHeadPtr^.next;
  178.       Deallocate(deallocPtr);
  179.     END;
  180.     WriteString(eraseLine);
  181.     Write(csi); WriteString(" p");   (* cursor on *)
  182.     WriteLn;
  183.   END Cleanup;
  184.  
  185.  
  186.  
  187. PROCEDURE GetArguments(VAR dir, old, new : String; VAR ws : WorkSet;
  188.                        VAR err : BOOLEAN);
  189.   VAR
  190.     argumentnumber, dummylength     :  INTEGER;
  191.     argnumwithoutoptions            :  INTEGER;
  192.     dummystring                     :  String;
  193.     i                               :  INTEGER;
  194.  
  195.   BEGIN
  196.     dir[0] := 0C;   (* initialize *)
  197.     old[0] := 0C;
  198.     new[0] := 0C;
  199.     err := FALSE;
  200.     argnumwithoutoptions := 0;
  201.  
  202.     argumentnumber := NumArgs();
  203.  
  204.     IF wbStarted THEN
  205.       Write(csi); WriteString(" p");   (* cursor on *)
  206.       WriteString("DIR/File:    ? ");
  207.       ReadLn(dir, dummylength);
  208.       IF dummylength = 0 THEN
  209.         dir := "";   (* current dir - where icon was located! *)
  210.       END;
  211.       WriteString("OldToolname: ? ");
  212.       ReadLn(old, dummylength);
  213.       IF dummylength # 0 THEN   (* input of an old tool name *)
  214.         ws := WorkSet{replace};
  215.         WriteString("NewToolname: ? ");
  216.         ReadLn(new, dummylength);
  217.         IF dummylength = 0 THEN   (* error no new toolname *)
  218.           err := TRUE;
  219.         END;
  220.       END;
  221.       IF NOT err THEN
  222.         WriteLn;
  223.         Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  224.         WriteString("On the options enter Y or J for to do it - ");
  225.         WriteString("anything else not to do it!!!");
  226.         WriteLn;
  227.         Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  228.         WriteString("Option interactive: ? ");
  229.         ReadLn(dummystring, dummylength);
  230.         IF ( (CAP(dummystring[0]) = "Y") OR
  231.              (CAP(dummystring[0]) = "J") )THEN
  232.           INCL(ws, interactive);
  233.         END;
  234.         WriteString("Option list:        ? ");
  235.         ReadLn(dummystring, dummylength);
  236.         IF ( (CAP(dummystring[0]) = "Y") OR
  237.              (CAP(dummystring[0]) = "J") )THEN
  238.           INCL(ws, list);
  239.         ELSE
  240.           WriteString("Option show:        ? ");
  241.           ReadLn(dummystring, dummylength);
  242.           IF ( (CAP(dummystring[0]) = "Y") OR
  243.                (CAP(dummystring[0]) = "J") )THEN
  244.             INCL(ws, show);
  245.           END;
  246.         END;
  247.         WriteLn;
  248.       END;   (* IF not err *)
  249.     ELSIF (argumentnumber >= 1) AND (argumentnumber <=6) THEN
  250.       FOR i := 1 TO argumentnumber DO
  251.         GetArg(i, dummystring, dummylength);
  252.         CapString(dummystring);
  253.         IF Compare("-S", dummystring) = 0 THEN
  254.           INCL(ws, show);
  255.         ELSIF Compare("-L", dummystring) = 0 THEN
  256.           INCL(ws, list);
  257.         ELSIF Compare("-I", dummystring) = 0 THEN
  258.           ws := ws + WorkSet{interactive};
  259.         ELSIF dummystring[0] = "-" THEN
  260.           err := TRUE;
  261.         ELSE
  262.           INC(argnumwithoutoptions);
  263.           CASE argnumwithoutoptions OF
  264.             1     :  GetArg(i, dir, dummylength);  |
  265.             2     :  GetArg(i, old, dummylength);
  266.                      INCL(ws, replace)|
  267.             3     :  GetArg(i, new, dummylength);  |
  268.             4, 5  :  err := TRUE;
  269.           END;   (* CASE *)
  270.         END;   (* IF *)
  271.       END;   (* FOR *)
  272.     ELSE
  273.       err := TRUE;
  274.     END;   (* IF wbStarted *)
  275.     IF NOT err THEN
  276.       IF (interactive IN ws) AND (NOT (replace IN ws)) THEN
  277.         EXCL(ws, interactive);
  278.       END;
  279.       IF ws = WorkSet{} THEN   (* no option and wrong amount of args *)
  280.         err := TRUE;
  281.       ELSIF (WorkSet{show, list} <= ws) OR
  282.             (WorkSet{show, interactive} <= ws) THEN
  283.         EXCL(ws, show);
  284.       END;
  285.       IF (replace IN ws) THEN
  286.         IF NOT wbStarted THEN
  287.           IF argnumwithoutoptions = 2 THEN   (* no dir/file as argument *)
  288.             new := old;
  289.             old := dir;
  290.             dir := "";   (* current dir *)
  291.           ELSIF argnumwithoutoptions # 3 THEN   (* wrong amount of args *)
  292.             err := TRUE;
  293.           END;   (* IF *)
  294.         END;
  295.         IF ( (old[0]="#") AND (old[1]="?") ) OR (old[0]="*") THEN
  296.           old[0] := "*";
  297.           old[1] := 0C;
  298.           IF ( NOT (interactive IN ws) ) THEN
  299.             WriteString("Are you sure, that you want to put ");
  300.             Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  301.             WriteString("everything");
  302.             Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  303.             WriteString(" to the"); WriteLn;
  304.             WriteString("   new Default-Tool-Name ? ");
  305.             Write(csi); WriteString(" p");   (* cursor on *)
  306.             ReadLn(dummystring, dummylength);
  307.             Write(csi); WriteString("0 p");   (* cursor off *)
  308.             IF NOT ( (CAP(dummystring[0]) = "Y") OR
  309.                      (CAP(dummystring[0]) = "J") )THEN
  310.               WriteLn;
  311.               WriteString("*** QUIT");
  312.               WriteLn;
  313.               Terminate(CurrentLevel());   (* Quit program *)
  314.             END;
  315.           END;   (* IF ( NOT (interactive *)
  316.         ELSIF ( (old[0]='"') AND (old[1]='"') ) THEN
  317.           old[0] := 0C;   (* old default is empty *)
  318.         END;   (* IF ( (old[0] *)
  319.         IF ( (new[0]='"') AND (new[1]='"') ) THEN
  320.           new[0] := 0C;   (* new default is empty *)
  321.         END;
  322.       END;   (* IF (replace *)
  323.     END;   (* IF NOT err *)
  324.   END GetArguments;
  325.  
  326.  
  327.  
  328. PROCEDURE ReplaceTool;
  329.   VAR
  330.     deallocPtr  :  ReplaceListPtr;
  331.     strPtr      :  POINTER TO String;
  332.  
  333.   BEGIN
  334.     icon := NIL;   (* initialize *)
  335.  
  336.     WriteString(eraseLine);
  337.     WriteLn;
  338.     WriteString("Replacing..."); WriteLn;
  339.     WHILE replaceListHeadPtr # NIL DO
  340.       CheckCtrlC;    (* check for CtrlC *)
  341.  
  342.       icon := GetDiskObject(ADR(replaceListHeadPtr^.name));
  343.       IF (icon # NIL) THEN
  344.         WriteString(replaceListHeadPtr^.name);
  345.         WriteString(".info: ");
  346.         Write (csi); WriteString ("0;32;40m");   (* color 2 *)
  347.         strPtr := icon^.defaultTool;
  348.         IF (strPtr^[0] = 0C) THEN
  349.           WriteString('""');
  350.         ELSE
  351.           WriteString(strPtr^);
  352.         END;
  353.         Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  354.         icon^.defaultTool := ADR(newToolname);
  355.         IF PutDiskObject(ADR(replaceListHeadPtr^.name), icon) = FALSE THEN
  356.           WriteString(" not replaced - Disk-error!!");
  357.         ELSE
  358.           WriteString(" replaced!");
  359.         END;
  360.         FreeDiskObject(icon);
  361.         icon := NIL;
  362.         Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  363.         WriteLn;
  364.       END;
  365.       deallocPtr := replaceListHeadPtr;
  366.       replaceListHeadPtr := replaceListHeadPtr^.next;
  367.       Deallocate(deallocPtr);
  368.     END;
  369.   END ReplaceTool;
  370.  
  371.  
  372.  
  373. PROCEDURE CheckFile(myLockList : LockListPtr; dir : BOOLEAN) : BOOLEAN;
  374.              (* dir = TRUE ; start from CheckDir - check directory
  375.                 dir = FALSE ; start from main program - check single file
  376.               *)
  377.   VAR
  378.     dummy, pathname,
  379.     comparestring       :  String;
  380.     strPtr              :  POINTER TO String;
  381.     pos                 :  INTEGER;
  382.     pathLength          :  CARDINAL;
  383.     newReplaceListPtr   :  ReplaceListPtr;
  384.     currentShowListPtr  :  ShowListPtr;
  385.     found               :  BOOLEAN;
  386.     inputstring         :  String;
  387.     dummylength         :  INTEGER;
  388.     doReplace           :  BOOLEAN;
  389.     noInput             :  BOOLEAN;
  390.  
  391.  
  392.   PROCEDURE ShowFile;
  393.     BEGIN
  394.       WriteString(eraseLine);
  395.       WriteString(pathname);
  396.       WriteString(".info: ");
  397.       Write (csi); WriteString ("0;32;40m");   (* color 2 *)
  398.       IF (strPtr^[0] = 0C) THEN
  399.         WriteString('""');
  400.       ELSE
  401.         WriteString(strPtr^);
  402.       END;
  403.       Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  404.     END ShowFile;
  405.  
  406.  
  407.   BEGIN
  408.     icon := NIL;   (* initialize *)
  409.     noInput := TRUE;
  410.  
  411.     CheckCtrlC;   (* check for CtrlC *)
  412.  
  413.     Copy(dummy, myLockList^.fib^.fileName);
  414.     pos := Occurs(dummy, 0, ".info", FALSE);
  415.     IF (pos # last) AND (CARDINAL(pos) = Length(dummy)-5) AND (pos # 0) THEN
  416.       Copy(pathname, myLockList^.name);
  417.       pathLength := Length(pathname);
  418.       IF (pathLength > 0) AND (pathname[pathLength-1] # ":") THEN
  419.         pathname[pathLength] := "/";
  420.         pathname[pathLength + 1] := 0C;
  421.       END;
  422.       IF dir THEN
  423.         dummy[Length(dummy) - 5] := 0C;
  424.         Concat(pathname, dummy);
  425.       ELSE
  426.         pathname := myLockList^.name;
  427.         pathname[Length(pathname) - 5] := 0C;
  428.       END;
  429.       icon := GetDiskObject(ADR(pathname));
  430.       IF icon # NIL THEN
  431.         strPtr := icon^.defaultTool;
  432.         IF (icon^.type = project) THEN
  433.           comparestring := strPtr^;
  434.           CapString(comparestring);
  435.           IF (replace IN myWorkSet) THEN
  436.             IF ( Compare(comparestring, oldToolname) = 0 ) OR
  437.                         (oldToolname[0] = "*") THEN
  438.               doReplace := TRUE;
  439.               IF interactive IN myWorkSet THEN
  440.                 REPEAT
  441.                   ShowFile;
  442.                   WriteString(" ? ");
  443.                   Write(csi); WriteString(" p");   (* cursor on *)
  444.                   noInput := FALSE;
  445.                   ReadLn(inputstring, dummylength);
  446.                   Write(csi); WriteString("0 p");   (* cursor off *)
  447.                   WriteString(eraseLine);
  448.                   IF (inputstring[0] = "?") THEN
  449.                     Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  450.                     WriteString("y/j=Yes / q=Quit / r=Replace now");
  451.                     WriteString(" / anything else=no action!");
  452.                     Write(csi);
  453.                     WriteString ("0;31;40m");   (* normal textstyle *)
  454.                     Write(csi); WriteString("F");   (* cursor up *)
  455.                   END;
  456.                 UNTIL (inputstring[0] # "?");
  457.                 IF ( CAP(inputstring[0]) = "Q" ) THEN
  458.                   FreeDiskObject(icon);
  459.                   icon := NIL;
  460.                   WriteLn;
  461.                   WriteString("*** QUIT");
  462.                   WriteLn;
  463.                   Terminate(CurrentLevel());   (* Quit program *)
  464.                 ELSIF ( CAP(inputstring[0]) = "R" ) THEN
  465.                   RETURN FALSE;   (* replace now *)
  466.                 ELSE
  467.                   doReplace := ( CAP(inputstring[0]) = "Y" ) OR
  468.                                ( CAP(inputstring[0]) = "J" );
  469.                 END;
  470.                 WriteString(myLockList^.name);
  471.               END;
  472.               IF doReplace THEN
  473.                 Allocate(newReplaceListPtr, SIZE(newReplaceListPtr^));
  474.                 Assert(newReplaceListPtr # NIL, ADR("Out of Memory!"));
  475.                 newReplaceListPtr^.next := replaceListHeadPtr;
  476.                 replaceListHeadPtr := newReplaceListPtr;
  477.                 replaceListHeadPtr^.name := pathname;
  478.               END;
  479.             END;   (* IF *)
  480.           END;   (* IF *)
  481.           IF (list IN myWorkSet) AND noInput THEN
  482.             ShowFile;
  483.             WriteLn;
  484.             WriteString(myLockList^.name);
  485.           END;
  486.           IF show IN myWorkSet THEN
  487.             IF (comparestring[0] = 0C) THEN
  488.               comparestring := '""';
  489.             END;
  490.             currentShowListPtr := showListHeadPtr;
  491.             found := FALSE;
  492.             WHILE (currentShowListPtr # NIL) AND (NOT found) DO
  493.               IF Compare(comparestring, currentShowListPtr^.name) = 0 THEN
  494.                 found := TRUE;
  495.               ELSE
  496.                 currentShowListPtr := currentShowListPtr^.next;
  497.               END;   (* IF *)
  498.             END;   (* WHILE *)
  499.             IF NOT found THEN
  500.               Allocate(currentShowListPtr, SIZE(currentShowListPtr^));
  501.               Assert(currentShowListPtr # NIL, ADR("Out of Memory!"));
  502.               currentShowListPtr^.next := showListHeadPtr;
  503.               showListHeadPtr := currentShowListPtr;
  504.               showListHeadPtr^.name := comparestring;
  505.               WriteString(eraseLine);
  506.               Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  507.               WriteString("Found:  ");
  508.               Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  509.               IF (strPtr^[0] = 0C) THEN
  510.                 WriteString('""');
  511.               ELSE
  512.                 WriteString(strPtr^);
  513.               END;
  514.               WriteLn;
  515.               WriteString(myLockList^.name);
  516.             END;   (* IF NOT found *)
  517.           END;   (* IF *)
  518.         END;   (* IF (strPtr[0] *)
  519.         FreeDiskObject(icon);
  520.         icon := NIL;
  521.       END;   (* IF icon # NIL *)
  522.     END;   (* IF (pos # last) *)
  523.     RETURN TRUE;
  524.   END CheckFile;
  525.  
  526.  
  527.  
  528. PROCEDURE CheckDir(myLockList : LockListPtr);
  529.   VAR
  530.     OK             :  BOOLEAN;
  531.     path           :  String;
  532.     pathLength     :  CARDINAL;
  533.  
  534.   BEGIN
  535.     WriteString(eraseLine);
  536.     WriteString(myLockList^.name);
  537.     REPEAT
  538.       CheckCtrlC;    (* check for CtrlC *)
  539.  
  540.       OK := ExNext(myLockList^.lock, myLockList^.fib) AND status;
  541.       IF OK AND (myLockList^.fib^.dirEntryType > 0) THEN
  542.         Copy(path, myLockList^.name);
  543.         pathLength := Length(path);
  544.         IF (pathLength > 0) AND (path[pathLength-1] # ":") THEN
  545.           path[pathLength] := "/";
  546.           path[pathLength + 1] := 0C;
  547.         END;
  548.         Concat(path, myLockList^.fib^.fileName);
  549.  
  550.         Allocate(myLockList^.next, SIZE(LockList));
  551.         Assert(myLockList^.next # NIL, ADR("Out of Memory!"));
  552.         WITH myLockList^.next^ DO
  553.           next := NIL;
  554.           name := path;
  555.           lock := Lock(ADR(path), sharedLock);
  556.           Assert(lock # NIL, ADR("Error: Lock!"));
  557.           Allocate(fib, SIZE(fib^));
  558.           Assert(fib # NIL, ADR("Out of Memory!"));
  559.           OK := Examine(lock, fib);
  560.           Assert(OK, ADR("Error: Examine!"));
  561.         END;   (* WITH *)
  562.         CheckDir(myLockList^.next);
  563.         WITH myLockList^.next^ DO
  564.           IF fib # NIL THEN
  565.             Deallocate(fib);
  566.           END;
  567.           IF lock # NIL THEN
  568.             UnLock(lock);
  569.           END;
  570.         END;   (* WITH *)
  571.         Deallocate(myLockList^.next);
  572.         myLockList^.next := NIL;
  573.       ELSIF OK AND (myLockList^.fib^.dirEntryType < 0) THEN
  574.         status := CheckFile(myLockList, TRUE);
  575.         OK := status;
  576.       END;
  577.     UNTIL NOT OK;
  578.   END CheckDir;
  579.  
  580.  
  581.  
  582. BEGIN   (* RDT *)
  583.   (* initialize *)
  584.   lockListHeadPtr := NIL;
  585.   replaceListHeadPtr := NIL;
  586.   showListHeadPtr := NIL;
  587.   TermProcedure(Cleanup);
  588.   DetectCtrlC(FALSE);
  589.   myWorkSet := WorkSet{};
  590.   error := FALSE;
  591.   status := TRUE;
  592.   eraseLine[0] := 15C;
  593.   eraseLine[1] := csi;
  594.   eraseLine[2] := "K";
  595.   eraseLine[3] := 0C;
  596.  
  597.   Write(csi); WriteString("0 p");   (* cursor off *)
  598.   WriteLn;
  599.   Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  600.   WriteString(copyright);
  601.   Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  602.   WriteLn; WriteLn;
  603.  
  604.   GetArguments(dirname, oldToolname, newToolname, myWorkSet, error);
  605.  
  606.   IF NOT error THEN
  607.     WriteString("In ");
  608.     Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  609.     IF dirname[0] = 0C THEN
  610.       WriteString("currentdir");
  611.     ELSE
  612.       WriteString(dirname);
  613.     END;
  614.     Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  615.     IF replace IN myWorkSet THEN
  616.       WriteString(" replace name ");
  617.       Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  618.       WriteString(oldToolname);
  619.       Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  620.       WriteString(" with ");
  621.       Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  622.       WriteString(newToolname);
  623.       Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  624.     END;
  625.     IF (list IN myWorkSet) OR (show IN myWorkSet)
  626.                            OR (interactive IN myWorkSet) THEN
  627.       WriteLn;
  628.       WriteString("   Option: ");
  629.       Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  630.       IF (list IN myWorkSet) THEN
  631.         WriteString("list! ");
  632.       ELSIF (show IN myWorkSet) THEN
  633.         WriteString("show! ");
  634.       END;
  635.       IF (interactive IN myWorkSet) THEN
  636.         WriteString("interactive!");
  637.       END;
  638.       Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  639.     END;   (* IF (list *)
  640.     WriteLn; WriteLn;
  641.  
  642.     CapString(oldToolname);
  643.     Allocate(lockListHeadPtr, SIZE(lockListHeadPtr^));
  644.     Assert(lockListHeadPtr # NIL, ADR("Out of Memory!"));
  645.  
  646.     lockListHeadPtr^.name := dirname;
  647.     lockListHeadPtr^.lock := Lock(ADR(lockListHeadPtr^.name), sharedLock);
  648.     IF lockListHeadPtr^.lock # NIL THEN   (* received lock *)
  649.       Allocate(lockListHeadPtr^.fib, SIZE(lockListHeadPtr^.fib^));
  650.       IF (lockListHeadPtr^.fib # NIL) AND
  651.           Examine(lockListHeadPtr^.lock, lockListHeadPtr^.fib) THEN
  652.         IF (lockListHeadPtr^.fib^.dirEntryType > 0) THEN   (* directory *)
  653.           WriteString("Searching...."); WriteLn;
  654.           CheckDir(lockListHeadPtr);
  655.         ELSE   (* file *)
  656.           status := CheckFile(lockListHeadPtr, FALSE);
  657.         END;   (* IF *)
  658.  
  659.         DeallocLockList;
  660.  
  661.         IF (replace IN myWorkSet) AND (replaceListHeadPtr # NIL) THEN
  662.           ReplaceTool;
  663.         ELSIF (replace IN myWorkSet) THEN
  664.           WriteString(eraseLine);
  665.           WriteLn;
  666.           Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  667.           WriteString("Nothing found to replace!");
  668.           Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  669.           WriteLn;
  670.         END;
  671.       END;   (* IF *)
  672.     ELSE   (* no lock! *)
  673.       Write (csi); WriteString ("0;33;40m");   (* color 3 *)
  674.       WriteString("Error: Couldn't get directory !");
  675.       Write(csi); WriteString ("0;31;40m");   (* normal textstyle *)
  676.       WriteLn;
  677.     END;
  678.   ELSE   (* error!!! *)
  679.     WriteString(usage);
  680.     WriteLn; WriteLn;
  681.     WriteString("  Replaces the default-icon in the icon-/.info file!");
  682.     WriteLn;
  683.     WriteString("    -l  :  lists all filenames with toolnames");
  684.     WriteLn;
  685.     WriteString("    -s  :  shows all available toolnames");
  686.     WriteLn;
  687.     WriteString("    -i  :  interactive - ? on input line for more help");
  688.     WriteLn;
  689.     WriteString("  * or #? for the OldToolname puts everything to");
  690.     WriteString(" the NewToolname!");
  691.     IF NOT wbStarted THEN
  692.       WriteLn; WriteLn;
  693.       WriteString("  e.g.:  RDT df0: -l"); WriteLn;
  694.       WriteString("         RDT df0: c:More c:MuchMore -s"); WriteLn;
  695.       WriteString("         RDT df1: c:* c:less -l");
  696.     END;
  697.     WriteLn;
  698.   END;
  699. END RDT.
  700.  
  701.